﻿using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using 数据;

public class 战斗脚本 : MonoBehaviour
{
    //游戏UI 
    public static 战斗脚本 单例;
    public Text 战斗信息_标签;
    public Text 等级信息_标签;
    public Text 金钱信息_标签;
    public Text 地图信息_标签;
    public Text 进度信息_标签;
    public GameObject 血条模板;
    //九龙坡、古藤林、九顶山、神魔之井、冰风谷、黄泉洞、草海、江都、霹雳堂、蓬莱迷宫、蜀山古道、神树、灵儿仙人洞、锁妖塔、剑冢上层西部、海底城、蓬莱地下迷宫 
    string[] 地图名称 = new string[10] { "璧山", "古藤林", "九顶山", "神魔之井", "冰风谷", "黄泉洞", "草海", "江都", "霹雳堂", "蓬莱迷宫", };
    string[] 武器材料 = new string[7] { "青铜", "白银", "黄金", "钻石", "黑金", "陨铁", "天石" };
    string[] 武器类型词 = new string[5] { "枪", "剑", "刀", "锤", "棍" };
    string[] 武器特性词 = new string[2] { "强力", "迅敏" };
    public Transform 怪物队伍面板;
    public Transform 玩家队伍面板;
    //声明数据容器
    public 玩家数据 玩家;
    public 怪物数据 怪物;
    public 系统数据 系统;

    public List<怪物队伍> 怪物队伍 = new List<怪物队伍>();
    public List<玩家队伍> 玩家队伍 = new List<玩家队伍>();

    public float 定时 = 5f;
    public float 计时;

    public bool 战斗中;
    public bool 加载完成;

    public bool 战斗结果 = false;
    public int 序号;

    public GameObject 玩家属性;
    //装备声明
    装备数据 新装备;
    public Text 装备名字;
    public Text 装备等级;
    public Text 装备品类;
    public Text 装备品级;
    public GameObject 词条预制体;
    public GameObject 词条父物体;

    public GameObject 物品详细属性_物体;
    void Start ()
    {
        单例 = this;
        系统 = new 系统数据();

        系统.关卡记录 = 1;
        系统.进度记录 = 1;
    }
    public void 加载战斗双方 ()
    {
        for (int i = 0; i < 玩家管理器.单例.玩家.玩家数据.Count; i++)
        {
            //添加玩家
            玩家队伍 玩家 = new 玩家队伍();
            GameObject go = Instantiate(血条模板);
            go.transform.SetParent(玩家队伍面板);
            go.transform.GetChild(4).GetComponent<RectTransform>().localPosition = new Vector2(213f, 7f);
            玩家.玩家血量数值_标签 = go.transform.GetChild(3).GetComponent<Text>();
            玩家.玩家血量条 = go.transform.GetComponent<Slider>();
            玩家.玩家攻击计时 = go.transform.GetChild(2).transform.GetComponent<Slider>();
            玩家队伍.Add(玩家);

            玩家队伍[i].玩家数据 = 玩家管理器.单例.玩家.玩家数据[i];
        }

        int 怪物数量= UnityEngine.Random.Range(1,2);
        for (int i = 0; i < 怪物数量; i++)
        {
            怪物队伍 怪物 = new 怪物队伍();
            GameObject go2 = Instantiate(血条模板);
            go2.transform.SetParent(怪物队伍面板);
            怪物.怪物血量数值_标签 = go2.transform.GetChild(3).GetComponent<Text>();
            怪物.怪物血量条 = go2.transform.GetComponent<Slider>();
            怪物.怪物血量条.direction = Slider.Direction.RightToLeft;
            怪物.怪物攻击计时 = go2.transform.GetChild(2).transform.GetComponent<Slider>();
            怪物.怪物攻击计时.direction = Slider.Direction.RightToLeft;
            怪物队伍.Add(怪物);            
            怪物队伍[i].怪物数据 = 获取怪物数据(系统.关卡记录);
        }

    }
   /* private void 加载战斗双方 ( int 我方队伍数量, int 敌方队伍数量 )
    {
        for (int i = 0; i < 我方队伍数量; i++)
        {
            //添加玩家
            玩家队伍 玩家 = new 玩家队伍();
            GameObject go = Instantiate(血条模板);
            go.transform.SetParent(玩家队伍面板);
            go.transform.GetChild(4).GetComponent<RectTransform>().localPosition = new Vector2(213f, 7f);
            玩家.玩家血量数值_标签 = go.transform.GetChild(3).GetComponent<Text>();
            玩家.玩家血量条 = go.transform.GetComponent<Slider>();
            玩家.玩家攻击计时 = go.transform.GetChild(2).transform.GetComponent<Slider>();
            玩家管理器.单例.玩家队伍.Add(玩家);
            初始化数据();
        }
        for (int i = 0; i < 敌方队伍数量; i++)
        {
            怪物队伍 怪物 = new 怪物队伍();
            GameObject go2 = Instantiate(血条模板);
            go2.transform.SetParent(怪物队伍面板);
            怪物.怪物血量数值_标签 = go2.transform.GetChild(3).GetComponent<Text>();
            怪物.怪物血量条 = go2.transform.GetComponent<Slider>();
            怪物.怪物血量条.direction = Slider.Direction.RightToLeft;
            怪物.怪物攻击计时 = go2.transform.GetChild(2).transform.GetComponent<Slider>();
            怪物.怪物攻击计时.direction = Slider.Direction.RightToLeft;
            怪物队伍.Add(怪物);


        }

    }*/
    怪物数据 获取怪物数据 (float 关卡数 )
    {
        怪物数据 怪物 = new 怪物数据();
        怪物.等级 = 1+ 关卡数;
        怪物.经验 = 0;
        怪物.伤害 = 1+关卡数;
        怪物.坚韧 = 0+ 关卡数;
        怪物.生命值 = 1+ 关卡数;
        怪物.最大生命值 = 1+关卡数;
        怪物.攻击 = 1+关卡数/3f;
        怪物.攻击间隔 = UnityEngine.Random.Range(2, 5);//多少秒攻击一次
        怪物.攻击计时 = 0;//现在游戏里过了多少秒.
        怪物.法术伤害 = 0;
        怪物.暴击率 = 0;
        怪物.闪避 = 0;
        怪物.减少暴击 = 0;
        怪物.力量 = 1+关卡数*10f;
        怪物.敏捷 = 1 + 关卡数 * 10f;
        怪物.体质 = 1 + 关卡数 * 10f;
        怪物.智力 = 1 + 关卡数 * 10f;
        return 怪物;
    }
    public void UI更新 ()
    {
        try
        {
            foreach (var item in 玩家队伍)
            {
                item.玩家血量数值_标签.text = $"{item.玩家数据.生命值}/{item.玩家数据.最大生命值}";


                item.玩家血量条.value = item.玩家数据.生命值 / item.玩家数据.最大生命值;

            }
            foreach (var item in 怪物队伍)
            {
                item.怪物血量数值_标签.text = $"{item.怪物数据.生命值}/{item.怪物数据.最大生命值}";
                item.怪物血量条.value = item.怪物数据.生命值 / item.怪物数据.最大生命值;
            }
            地图信息_标签.text = "地图:" + 地图名称[Convert.ToInt32(系统.关卡记录)];
            进度信息_标签.text = "进度:" + 地图名称[Convert.ToInt32(系统.关卡记录)] + "-" + 系统.进度记录;
        }
        catch (Exception ex)
        {
            print(ex.Message);
            throw;
        }

    }
    //地图按钮
    public void 地图加方法 ()
    {
        系统.关卡记录 += 1;
        系统.进度记录 = 0;
        清理队伍面板();
        战斗中 = false;
        玩家队伍.Clear();
        怪物队伍.Clear();
    }
    public void 地图减方法 ()
    {
        系统.关卡记录 -= 1;
        系统.进度记录 = 0;
        清理队伍面板();
        战斗中 = false;
        玩家队伍.Clear();
        怪物队伍.Clear();
    }
    public void 进度加方法 ()
    {
        系统.进度记录 += 1;
        清理队伍面板();
        战斗中 = false;
        玩家队伍.Clear();
        怪物队伍.Clear();
    }
    public void 进度减方法 ()
    {
        系统.进度记录 -= 1;
        清理队伍面板();
        战斗中 = false;
        玩家队伍.Clear();
        怪物队伍.Clear();
    }
    // 攻速 等于多少秒出手一次;
    public void 玩家战斗逻辑 ()
    {
        foreach (var item in 玩家队伍)
        {
            if (item.玩家数据.生命值 > 0)
            {
                item.玩家数据.攻击计时 += Time.deltaTime;
                item.玩家攻击计时.value = item.玩家数据.攻击计时 / item.玩家数据.攻击间隔;
                if (item.玩家数据.攻击计时 >= item.玩家数据.攻击间隔)
                {
                    foreach (var item1 in 怪物队伍)
                    {
                        if (item1.怪物数据.生命值 <= 0)
                        {

                        }
                        else
                        {
                            item1.怪物数据.生命值 -= item.玩家数据.攻击;
                            break;
                        }
                    }

                    item.玩家数据.攻击计时 = 0;
                    序号++;
                    战斗信息_标签.text += DateTime.Now.ToString("hh:mm:ss")+ $"<color=green>玩家进行攻击,造成<size=50><color=red>{item.玩家数据.攻击.ToString("0")}</color></size>点伤害!</color>{序号}\n";
                }
            }

        }

    }
    public void 敌人战斗逻辑 ()
    {
        foreach (var item in 怪物队伍)
        {
            if (item.怪物数据.生命值 > 0)
            {
                item.怪物数据.攻击计时 += Time.deltaTime;
                item.怪物攻击计时.value = item.怪物数据.攻击计时 / item.怪物数据.攻击间隔;
                if (item.怪物数据.攻击计时 >= item.怪物数据.攻击间隔)
                {
                    foreach (var item1 in 玩家队伍)
                    {
                        if (item1.玩家数据.生命值 <= 0)
                        {

                        }
                        else
                        {
                            item1.玩家数据.生命值 -= item.怪物数据.攻击;
                            break;
                        }
                    }

                    item.怪物数据.攻击计时 = 0;
                    序号++;
                    战斗信息_标签.text += DateTime.Now.ToString("hh:mm:ss") + $"<color=blcak>怪物进行攻击,造成<size=50><color=red>{item.怪物数据.攻击.ToString("0")}</color></size>点伤害!</color>{序号}\n";
                }
            }

        }
    }
   
    private void 清理队伍面板 ()
    {
        if (怪物队伍面板.childCount > 0)
        {
            for (int i = 0; i < 怪物队伍面板.childCount; i++)
            {
                Destroy(怪物队伍面板.GetChild(i).gameObject);
            }
        }
        if (玩家队伍面板.childCount > 0)
        {
            for (int i = 0; i < 玩家队伍面板.childCount; i++)
            {
                Destroy(玩家队伍面板.GetChild(i).gameObject);
            }
        }
    }
    private void 胜负判断 ()
    {
        float 玩家队伍血量 = 0;
        float 敌人队伍血量 = 0;
        foreach (var item in 怪物队伍)
        {
            敌人队伍血量 += item.怪物数据.生命值;
        }
        foreach (var item in 玩家队伍)
        {
            玩家队伍血量 += item.玩家数据.生命值;
        }

        if (敌人队伍血量 <= 0)
        {
            print("玩家胜利");
            战斗信息_标签.text += DateTime.Now.ToString("hh:mm:ss") + "<color=yello><size=70> 玩家胜利!!</size></color>\n";
            清理队伍面板();
            战斗中 = false;
            玩家队伍.Clear();
            怪物队伍.Clear();
            奖励生成计算(系统.进度记录);
            系统.进度记录 += 1;
            if (系统.进度记录 >= 系统.关卡记录 * 10f)
            {
                系统.关卡记录 += 1;
            }
        }
        else if (玩家队伍血量 <= 0)
        {
            print("敌人胜利");
            战斗信息_标签.text += DateTime.Now.ToString("hh:mm:ss") + "<size=70> 敌人胜利!!</size>\n";
            清理队伍面板();
            战斗中 = false;
            玩家队伍.Clear();
            怪物队伍.Clear();
            if (系统.进度记录>1)
            {
                系统.进度记录 -= 1;
            }
           
            if (系统.进度记录 >= 系统.关卡记录 * 10f)
            {
                系统.关卡记录 += 1;
            }
        }

    }
   private void 装备生成 ()
    {

        新装备 = new 装备数据();
        新装备.装备id = 1001;
        新装备.装备名称 = "木剑";
        新装备.装备品类 = 0;
        新装备.装备品级 = 3;//绿色
        新装备.装备等级 = 0;//0级可以使用
        int 基础词条= UnityEngine.Random.Range(0, 6);
        for (int i = 0; i < 基础词条; i++)
        {
            bool 循环 = true;
            while (循环)
            {
                int 基础词条类别 = UnityEngine.Random.Range(0, 6);
                float 基础词条数据 = UnityEngine.Random.Range(1f, 5.5f);
                if (新装备.装备基础词条.ContainsKey(基础词条类别) == false)
                {
                    新装备.装备基础词条.Add(基础词条类别, 基础词条数据);
                    循环 = false;
                }
            }


        }

        if (新装备.装备品级 >= 1)
        {
            for (int i = 0; i < 新装备.装备品级; i++)
            {
                bool 循环 = true;
                while (循环)
                {
                    int 额外词条类别 = UnityEngine.Random.Range(0, 6);
                    float 额外词条数据 = UnityEngine.Random.Range(1f, 5.5f);
                    if (新装备.装备额外词条.ContainsKey(额外词条类别) == false)
                    {
                        新装备.装备额外词条.Add(额外词条类别, 额外词条数据);
                        循环 = false;
                    }
                }
            }
           
        }


    }
    private 装备数据 装备生成 (float 关卡数) {
        新装备 = new 装备数据();
        新装备.装备id = UnityEngine.Random.Range(1000,9999);
        新装备.装备品类= UnityEngine.Random.Range(0,4);//
        新装备.装备品级 = UnityEngine.Random.Range(0, 6);
        //比如 关卡是 5  我们出一级的  关卡数是 5-9的时候我们出5级, 关卡数 10-14的时候我们出10级.
        if (关卡数<5)
        {
            新装备.装备等级 =1;//0级可以使用
        }
        else if(关卡数<10&& 关卡数 >= 5)
        {
            新装备.装备等级 = 5;
        }
        else if (关卡数 <15 && 关卡数 >= 10)
        {
            新装备.装备等级 = 10;
        }
        else if (关卡数 < 20 && 关卡数 >= 15)
        {
            新装备.装备等级 = 15;
        }
         int 随机基础词条=  UnityEngine.Random.Range(0, 5);
        for (int i = 0; i < 随机基础词条; i++)
        {
            bool 循环 = true;
            while (循环)
            {
                int 基础词条类别 = UnityEngine.Random.Range(0, 6);
                
                float 基础词条数据 = (float)double.Parse(UnityEngine.Random.Range(1f, 5.5f).ToString("0.00"));
                
                if (新装备.装备基础词条.ContainsKey(基础词条类别) == false)
                {
                   
                    新装备.装备基础词条.Add(基础词条类别, 基础词条数据);
                    循环 = false;
                }
            }
        }

        if (新装备.装备品级 >= 1)
        {
            for (int i = 0; i < 新装备.装备品级; i++)
            {
                bool 循环 = true;
                while (循环)
                {
                    int 额外词条类别 = UnityEngine.Random.Range(0, 6);
                    float 额外词条数据 =(float)double.Parse(UnityEngine.Random.Range(1f, 5.5f).ToString("0.00"));
                    if (新装备.装备额外词条.ContainsKey(额外词条类别) == false)
                    {
                        新装备.装备额外词条.Add(额外词条类别, 额外词条数据);
                        循环 = false;
                    }
                }
            }

        }

       // DoTest();
        string 装备名称 = 武器材料[UnityEngine.Random.Range(0,7)]; 
        新装备.装备名称 = 装备名称+武器类型词[UnityEngine.Random.Range(0,5)];
        //查看属性(新装备);

        return 新装备;
    }
    public void 查看属性 (装备数据 装备)
    {
        物品详细属性_物体.SetActive(true);
       // 装备生成();
        装备名字.text = 装备.装备名称;
        装备等级.text = 装备.装备等级.ToString()+"级";
        //品类显示
        if (装备.装备品类 == 0)
        {
            装备品类.text = "武器";
        }
        else if (装备.装备品类 == 1)
        {
            装备品类.text = "防具";
        }
        else if (装备.装备品类 == 2)
        {
            装备品类.text = "首饰";
        }
        else if (装备.装备品类 == 3)
        {
            装备品类.text = "护身符";
        }
        //品级显示
        if (装备.装备品级 == 0)
        {
            装备品级.text = "白色";
        }
        else if (装备.装备品级 == 1)
        {
            装备品级.text = "绿色";
        }
        else if (装备.装备品级 == 2)
        {
            装备品级.text = "蓝色";
        }
        else if (装备.装备品级 == 3)
        {
            装备品级.text = "紫色";
        }
        else if (装备.装备品级 == 4)
        {
            装备品级.text = "金色";
        }
        else if (装备.装备品级 == 5)
        {
            装备品级.text = "红色";
        }
        if (词条父物体.transform.childCount>4)
        {
            for (int i = 4; i < 词条父物体.transform.childCount; i++)
            {
                Destroy(词条父物体.transform.GetChild(i).gameObject);
            }
        }
        if (装备.装备基础词条.Count > 0)
        {

          
                foreach (var item in 装备.装备基础词条)
                {
                    GameObject go = Instantiate(词条预制体);
                    go.transform.SetParent(词条父物体.transform);
                    //0-生命. 1-防御. 2-力量,3敏捷,4体质.5智力
                    if (item.Key == 0)
                    {
                        go.GetComponent<Text>().text = "生命+" + item.Value;
                    }
                    else if (item.Key == 1)
                    {
                        go.GetComponent<Text>().text = "防御+" + item.Value;
                    }
                    else if (item.Key == 2)
                    {
                        go.GetComponent<Text>().text = "力量+" + item.Value;
                    }
                    else if (item.Key == 3)
                    {
                        go.GetComponent<Text>().text = "敏捷+" + item.Value;
                    }
                    else if (item.Key == 4)
                    {
                        go.GetComponent<Text>().text = "体质+" + item.Value;
                    }
                    else if (item.Key == 5)
                    {
                        go.GetComponent<Text>().text = "智力+" + item.Value;
                    }
                }
            
           

        }


        if (装备.装备额外词条.Count > 0)
        {

           
                foreach (var item in 装备.装备额外词条)
                {
                    GameObject go = Instantiate(词条预制体);
                    go.transform.SetParent(词条父物体.transform);
                    //0-攻击间隔,1暴击率,2-闪避,3-命中,7-减少暴击,8-伤害
                    if (item.Key ==0)
                    {
                        go.GetComponent<Text>().text = "攻击间隔+" + item.Value;
                    }
                    else if (item.Key == 1)
                    {
                        go.GetComponent<Text>().text = "暴击率+" + item.Value;
                    }
                    else if (item.Key == 2)
                    {
                        go.GetComponent<Text>().text = "闪避+" + item.Value;
                    }
                    else if (item.Key == 3)
                    {
                        go.GetComponent<Text>().text = "命中+" + item.Value;
                    }
                    else if (item.Key == 4)
                    {
                        go.GetComponent<Text>().text = "减少暴击+" + item.Value;
                    }
                    else if (item.Key == 5)
                    {
                        go.GetComponent<Text>().text = "伤害+" + item.Value;
                    }
                }
            
        }



    }
    // Update is called once per frame
    private void 计时方法 ()
    {
        计时 += Time.deltaTime;
        //print();
        if (计时 >= 定时)
        {
            计时 = 0;
            for (int i = 0; i < 玩家管理器.单例.玩家.玩家数据.Count; i++)
            {
                玩家管理器.单例.玩家.玩家数据[i].生命值= 玩家管理器.单例.玩家.玩家数据[i].最大生命值;
            }
          
            加载战斗双方();
            战斗中 = true;
        }
    }

    private void 奖励生成计算 (float 关卡数)
    {
        for (int i = 0; i < 玩家管理器.单例.玩家.玩家数据.Count; i++)
        {
            玩家管理器.单例.玩家.玩家数据[i].经验 += 关卡数;
            战斗信息_标签.text += DateTime.Now.ToString("hh:mm:ss") + "获得经验" + 关卡数 + "点\n";
            玩家经验计算(玩家管理器.单例.玩家.玩家数据[i].经验,i);
            //   
        }
        if (UnityEngine.Random.Range(0, 100) < 90)
        {
            装备数据 装备= 装备生成 (关卡数);
            玩家管理器.单例.玩家.玩家装备.Add(装备);
            物品栏脚本.单例.打开背包_方法();
            print("玩家获得一件装备.");
            string 装备数据 = 装备.装备名称 + "\n" + 装备.装备等级 + "\n" + 装备.装备品级;
            战斗信息_标签.text += DateTime.Now.ToString("hh:mm:ss") + "玩家获得一件装备!\n"+ 装备数据;
        }

    }

   // private Dictionary<int, float> 装备基础词条 = new Dictionary<int, float>();
   // private int 装备品级;
    private int[] 装备词条类别数组 = { 0, 1, 2, 3, 4, 5 };
    public void DoTest ()
    {
        int[] shuffledArray = ShuffleCopy(装备词条类别数组);
        for (int i = 0; i < 新装备.装备品级; i++)
        {
            float 装备词条数据 = UnityEngine.Random.Range(0.1f, 5.5f);
           新装备.装备基础词条.Add(shuffledArray[i], 装备词条数据);
        }
    }

    //int数组乱序
    public int[] ShuffleCopy ( int[] array )//int数值乱序
    {
        System.Random r = new System.Random();
        for (var i = array.Length - 1; i > 0; --i)
        {
            int randomIndex = r.Next(i + 1);
            int temp = array[i];
            array[i] = array[randomIndex];
            array[randomIndex] = temp;
        }
        return array;
    }
    private void 玩家经验计算 (float 经验,int 序号)
    {
        if (经验>= 玩家管理器.单例.玩家.玩家数据[序号].等级*10f)
        {
            //先去除 需要的经验
            玩家管理器.单例.玩家.玩家数据[序号].经验 -= 玩家管理器.单例.玩家.玩家数据[序号].等级 * 10f;
            //然后增加等级
            玩家管理器.单例.玩家.玩家数据[序号].等级 += 1;
            战斗信息_标签.text += DateTime.Now.ToString("hh:mm:ss") + "恭喜您升级了!!当前为:" + 玩家管理器.单例.玩家.玩家数据[序号].等级 + "级\n";
            //最后 让玩家角色成长;
            玩家管理器.单例.玩家.玩家数据[序号].力量 += 1f;
            玩家管理器.单例.玩家.玩家数据[序号].敏捷 += 1f;
            玩家管理器.单例.玩家.玩家数据[序号].体质 += 1f;
            玩家管理器.单例.玩家.玩家数据[序号].智力 += 1f;
            玩家管理器.单例.玩家.玩家数据[序号].最大生命值 += 2f;
            玩家管理器.单例.玩家.玩家数据[序号].攻击 += 1;


        }
        
    }
    void Update ()
    {
        //战斗中为 真, 我们进行战斗逻辑
        if (战斗中 == true)
        {
            if (加载完成 == false)
            {
                加载完成 = true;
            }


            玩家战斗逻辑();
            敌人战斗逻辑();
            胜负判断();
            UI更新();
        }
        //战斗中为 假, 我们进行战斗结算,等待 加载
        else
        {

            加载完成 = false;
            计时方法();
        }

    }
 
    
}
